home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / managers / dragClasses / DragProxy.as
Text File  |  2014-03-27  |  12KB  |  358 lines
  1. package mx.managers.dragClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.InteractiveObject;
  6.    import flash.events.Event;
  7.    import flash.events.KeyboardEvent;
  8.    import flash.events.MouseEvent;
  9.    import flash.geom.Point;
  10.    import mx.core.DragSource;
  11.    import mx.core.IUIComponent;
  12.    import mx.core.UIComponent;
  13.    import mx.core.mx_internal;
  14.    import mx.effects.Move;
  15.    import mx.effects.Zoom;
  16.    import mx.events.DragEvent;
  17.    import mx.events.EffectEvent;
  18.    import mx.managers.CursorManager;
  19.    import mx.managers.DragManager;
  20.    import mx.managers.ISystemManager;
  21.    import mx.styles.CSSStyleDeclaration;
  22.    import mx.styles.StyleManager;
  23.    
  24.    use namespace mx_internal;
  25.    
  26.    public class DragProxy extends UIComponent
  27.    {
  28.       
  29.       mx_internal static const VERSION:String = "3.0.0.0";
  30.        
  31.       
  32.       public var allowMove:Boolean = true;
  33.       
  34.       private var cursorClass:Class = null;
  35.       
  36.       public var action:String;
  37.       
  38.       public var target:IUIComponent = null;
  39.       
  40.       public var dragInitiator:IUIComponent;
  41.       
  42.       private var lastMouseEvent:MouseEvent;
  43.       
  44.       public var yOffset:Number;
  45.       
  46.       public var dragSource:DragSource;
  47.       
  48.       private var cursorID:int = 0;
  49.       
  50.       public var xOffset:Number;
  51.       
  52.       public var startX:Number;
  53.       
  54.       public var startY:Number;
  55.       
  56.       private var lastKeyEvent:KeyboardEvent;
  57.       
  58.       public function DragProxy(param1:IUIComponent, param2:DragSource)
  59.       {
  60.          super();
  61.          this.dragInitiator = param1;
  62.          this.dragSource = param2;
  63.          var _loc3_:ISystemManager = param1.systemManager.topLevelSystemManager;
  64.          _loc3_.addEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  65.          _loc3_.addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  66.          _loc3_.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  67.          _loc3_.addEventListener(KeyboardEvent.KEY_UP,keyUpHandler);
  68.       }
  69.       
  70.       public function mouseUpHandler(param1:MouseEvent) : void
  71.       {
  72.          var _loc2_:DragEvent = null;
  73.          var _loc5_:Point = null;
  74.          var _loc6_:Move = null;
  75.          var _loc7_:Zoom = null;
  76.          var _loc8_:Move = null;
  77.          var _loc3_:ISystemManager = dragInitiator.systemManager.topLevelSystemManager;
  78.          _loc3_.removeEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  79.          stage.removeEventListener(MouseEvent.MOUSE_MOVE,stage_mouseMoveHandler);
  80.          _loc3_.removeEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  81.          _loc3_.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  82.          stage.removeEventListener(Event.MOUSE_LEAVE,mouseLeaveHandler);
  83.          _loc3_.removeEventListener(KeyboardEvent.KEY_UP,keyUpHandler);
  84.          var _loc4_:Object = automationDelegate;
  85.          if(target && action != DragManager.NONE)
  86.          {
  87.             _loc2_ = new DragEvent(DragEvent.DRAG_DROP);
  88.             _loc2_.dragInitiator = dragInitiator;
  89.             _loc2_.dragSource = dragSource;
  90.             _loc2_.action = action;
  91.             _loc2_.ctrlKey = param1.ctrlKey;
  92.             _loc2_.altKey = param1.altKey;
  93.             _loc2_.shiftKey = param1.shiftKey;
  94.             (_loc5_ = new Point()).x = lastMouseEvent.localX;
  95.             _loc5_.y = lastMouseEvent.localY;
  96.             _loc5_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc5_);
  97.             _loc5_ = DisplayObject(target).globalToLocal(_loc5_);
  98.             _loc2_.localX = _loc5_.x;
  99.             _loc2_.localY = _loc5_.y;
  100.             if(_loc4_)
  101.             {
  102.                _loc4_.recordAutomatableDragDrop(target,_loc2_);
  103.             }
  104.             target.dispatchEvent(_loc2_);
  105.          }
  106.          else
  107.          {
  108.             action = DragManager.NONE;
  109.          }
  110.          if(action == DragManager.NONE)
  111.          {
  112.             (_loc6_ = new Move(this)).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  113.             _loc6_.xFrom = x;
  114.             _loc6_.yFrom = y;
  115.             _loc6_.xTo = startX;
  116.             _loc6_.yTo = startY;
  117.             _loc6_.duration = 200;
  118.             _loc6_.play();
  119.          }
  120.          else
  121.          {
  122.             _loc7_ = new Zoom(this);
  123.             _loc7_.zoomWidthFrom = _loc7_.zoomHeightFrom = 1;
  124.             _loc7_.zoomWidthTo = _loc7_.zoomHeightTo = 0;
  125.             _loc7_.duration = 200;
  126.             _loc7_.play();
  127.             (_loc8_ = new Move(this)).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  128.             _loc8_.xFrom = x;
  129.             _loc8_.yFrom = this.y;
  130.             _loc8_.xTo = parent.mouseX;
  131.             _loc8_.yTo = parent.mouseY;
  132.             _loc8_.duration = 200;
  133.             _loc8_.play();
  134.          }
  135.          _loc2_ = new DragEvent(DragEvent.DRAG_COMPLETE);
  136.          _loc2_.dragInitiator = dragInitiator;
  137.          _loc2_.dragSource = dragSource;
  138.          _loc2_.relatedObject = InteractiveObject(target);
  139.          _loc2_.action = action;
  140.          _loc2_.ctrlKey = param1.ctrlKey;
  141.          _loc2_.altKey = param1.altKey;
  142.          _loc2_.shiftKey = param1.shiftKey;
  143.          dragInitiator.dispatchEvent(_loc2_);
  144.          if(_loc4_ && action == DragManager.NONE)
  145.          {
  146.             _loc4_.recordAutomatableDragCancel(dragInitiator,_loc2_);
  147.          }
  148.          cursorManager.removeCursor(cursorID);
  149.          cursorID = CursorManager.NO_CURSOR;
  150.          this.lastMouseEvent = null;
  151.       }
  152.       
  153.       public function showFeedback() : void
  154.       {
  155.          var _loc1_:Class = cursorClass;
  156.          var _loc2_:CSSStyleDeclaration = StyleManager.getStyleDeclaration("DragManager");
  157.          if(action == DragManager.COPY)
  158.          {
  159.             _loc1_ = _loc2_.getStyle("copyCursor");
  160.          }
  161.          else if(action == DragManager.LINK)
  162.          {
  163.             _loc1_ = _loc2_.getStyle("linkCursor");
  164.          }
  165.          else if(action == DragManager.NONE)
  166.          {
  167.             _loc1_ = _loc2_.getStyle("rejectCursor");
  168.          }
  169.          else
  170.          {
  171.             _loc1_ = _loc2_.getStyle("moveCursor");
  172.          }
  173.          if(_loc1_ != cursorClass)
  174.          {
  175.             cursorClass = _loc1_;
  176.             if(cursorID != CursorManager.NO_CURSOR)
  177.             {
  178.                cursorManager.removeCursor(cursorID);
  179.             }
  180.             cursorID = cursorManager.setCursor(cursorClass,2,0,0);
  181.          }
  182.       }
  183.       
  184.       override public function initialize() : void
  185.       {
  186.          super.initialize();
  187.          stage.addEventListener(MouseEvent.MOUSE_MOVE,stage_mouseMoveHandler);
  188.          stage.addEventListener(Event.MOUSE_LEAVE,mouseLeaveHandler);
  189.          if(!getFocus())
  190.          {
  191.             setFocus();
  192.          }
  193.       }
  194.       
  195.       public function mouseMoveHandler(param1:MouseEvent) : void
  196.       {
  197.          var _loc2_:DragEvent = null;
  198.          var _loc3_:DisplayObject = null;
  199.          var _loc4_:int = 0;
  200.          var _loc12_:Boolean = false;
  201.          var _loc13_:IUIComponent = null;
  202.          lastMouseEvent = param1;
  203.          var _loc5_:Point = new Point();
  204.          var _loc6_:Point = new Point(param1.localX,param1.localY);
  205.          _loc6_ = DisplayObject(param1.target).localToGlobal(_loc6_);
  206.          var _loc7_:Number = (_loc6_ = DisplayObject(dragInitiator.systemManager.topLevelSystemManager).globalToLocal(_loc6_)).x;
  207.          var _loc8_:Number = _loc6_.y;
  208.          x = _loc7_ - xOffset;
  209.          y = _loc8_ - yOffset;
  210.          if(!param1)
  211.          {
  212.             return;
  213.          }
  214.          var _loc9_:Array = DisplayObjectContainer(dragInitiator.systemManager.topLevelSystemManager).getObjectsUnderPoint(new Point(_loc7_,_loc8_));
  215.          var _loc10_:DisplayObject = null;
  216.          var _loc11_:int = _loc9_.length - 1;
  217.          while(_loc11_ >= 0)
  218.          {
  219.             if((_loc10_ = _loc9_[_loc11_]) != this && !contains(_loc10_))
  220.             {
  221.                break;
  222.             }
  223.             _loc11_--;
  224.          }
  225.          if(target)
  226.          {
  227.             _loc12_ = false;
  228.             _loc13_ = target;
  229.             _loc3_ = _loc10_;
  230.             while(_loc3_)
  231.             {
  232.                if(_loc3_ == target)
  233.                {
  234.                   dispatchDragEvent(DragEvent.DRAG_OVER,param1,_loc3_);
  235.                   _loc12_ = true;
  236.                   break;
  237.                }
  238.                dispatchDragEvent(DragEvent.DRAG_ENTER,param1,_loc3_);
  239.                if(target == _loc3_)
  240.                {
  241.                   _loc12_ = false;
  242.                   break;
  243.                }
  244.                _loc3_ = _loc3_.parent;
  245.             }
  246.             if(!_loc12_)
  247.             {
  248.                dispatchDragEvent(DragEvent.DRAG_EXIT,param1,_loc13_);
  249.                if(target == _loc13_)
  250.                {
  251.                   target = null;
  252.                }
  253.             }
  254.          }
  255.          if(!target)
  256.          {
  257.             action = DragManager.MOVE;
  258.             _loc3_ = _loc10_;
  259.             while(_loc3_)
  260.             {
  261.                if(_loc3_ != this)
  262.                {
  263.                   dispatchDragEvent(DragEvent.DRAG_ENTER,param1,_loc3_);
  264.                   if(target)
  265.                   {
  266.                      break;
  267.                   }
  268.                }
  269.                _loc3_ = _loc3_.parent;
  270.             }
  271.             if(!target)
  272.             {
  273.                action = DragManager.NONE;
  274.             }
  275.          }
  276.          showFeedback();
  277.       }
  278.       
  279.       private function dispatchDragEvent(param1:String, param2:MouseEvent, param3:Object) : void
  280.       {
  281.          var _loc4_:DragEvent = new DragEvent(param1);
  282.          var _loc5_:Point = new Point();
  283.          _loc4_.dragInitiator = dragInitiator;
  284.          _loc4_.dragSource = dragSource;
  285.          _loc4_.action = action;
  286.          _loc4_.ctrlKey = param2.ctrlKey;
  287.          _loc4_.altKey = param2.altKey;
  288.          _loc4_.shiftKey = param2.shiftKey;
  289.          _loc5_.x = lastMouseEvent.localX;
  290.          _loc5_.y = lastMouseEvent.localY;
  291.          _loc5_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc5_);
  292.          _loc5_ = DisplayObject(param3).globalToLocal(_loc5_);
  293.          _loc4_.localX = _loc5_.x;
  294.          _loc4_.localY = _loc5_.y;
  295.          param3.dispatchEvent(_loc4_);
  296.       }
  297.       
  298.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  299.       {
  300.          checkKeyEvent(param1);
  301.       }
  302.       
  303.       private function effectEndHandler(param1:EffectEvent) : void
  304.       {
  305.          DragManager.mx_internal::endDrag();
  306.       }
  307.       
  308.       public function checkKeyEvent(param1:KeyboardEvent) : void
  309.       {
  310.          var _loc2_:DragEvent = null;
  311.          var _loc3_:Point = null;
  312.          if(target)
  313.          {
  314.             if(lastKeyEvent && param1.type == lastKeyEvent.type && param1.keyCode == lastKeyEvent.keyCode)
  315.             {
  316.                return;
  317.             }
  318.             lastKeyEvent = param1;
  319.             _loc2_ = new DragEvent(DragEvent.DRAG_OVER);
  320.             _loc2_.dragInitiator = dragInitiator;
  321.             _loc2_.dragSource = dragSource;
  322.             _loc2_.action = action;
  323.             _loc2_.ctrlKey = param1.ctrlKey;
  324.             _loc2_.altKey = param1.altKey;
  325.             _loc2_.shiftKey = param1.shiftKey;
  326.             _loc3_ = new Point();
  327.             _loc3_.x = lastMouseEvent.localX;
  328.             _loc3_.y = lastMouseEvent.localY;
  329.             _loc3_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc3_);
  330.             _loc3_ = DisplayObject(target).globalToLocal(_loc3_);
  331.             _loc2_.localX = _loc3_.x;
  332.             _loc2_.localY = _loc3_.y;
  333.             target.dispatchEvent(_loc2_);
  334.             showFeedback();
  335.          }
  336.       }
  337.       
  338.       public function mouseLeaveHandler(param1:Event) : void
  339.       {
  340.          mouseUpHandler(lastMouseEvent);
  341.       }
  342.       
  343.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  344.       {
  345.          checkKeyEvent(param1);
  346.       }
  347.       
  348.       public function stage_mouseMoveHandler(param1:MouseEvent) : void
  349.       {
  350.          if(param1.target != stage)
  351.          {
  352.             return;
  353.          }
  354.          mouseMoveHandler(param1);
  355.       }
  356.    }
  357. }
  358.